

import { generateId } from '@/utils/index'
import _ from 'lodash'
// filter与表达式:
// 属性、聚合函数、单位转换函数(unitconversion)、
// list函数、str函数、file函数、
// json函数、math函数、time函数、
// map函数、其它函数、操作符


// fuction:
// rdbms、streamingml、file、其它
// 窗口:
// 常用(time、timeBatch、length、lengthBatch、timeLength、session、batch)
// 其它(所有剩余)
//整理流处理方法数组
const windType = ['time', 'timeBatch', 'length', 'lengthBatch', 'timeLength', 'session', 'batch']
// 过滤整理
// const funType = ['list', 'file', 'str', 'json', 'math', 'time']
export function setFunctiondata(data, nodeObj) {
    let newData = JSON.parse(JSON.stringify(data))
    const { extensions, inBuilt } = newData
    const { windowProcessors } = inBuilt
    const type = ['rdbms', 'file', 'streamingml']
    const keys = Object.keys(extensions)
    let arr = []
    let funArr = [
        {
            name: '属性',
            val: 'attr',
            list: []
        },
        {
            name: '聚合函数',
            val: 'juheFun',
            list: []
        },
        {
            name: '单位转换函数',
            val: 'danweiFun',
            list: []
        },
        {
            name: 'list',
            val: 'list',
            list: []
        },
        {
            name: 'file',
            list: [],
            val: 'file',
        },
        {
            name: 'str',
            list: [],
            val: 'str',
        },
        {
            name: 'json',
            list: [],
            val: 'json',
        },
        {
            name: 'math',
            list: [],
            val: 'math',
        },
        {
            name: 'time',
            list: [],
            val: 'time',
        },
        {
            name: '其它函数',
            list: [],
            val: 'otherFun',
        },

    ]
    let funArrAll = [
        {
            name: '属性',
            val: 'attr',
            list: []
        },
        {
            name: '聚合函数',
            val: 'juheFun',
            list: []
        },
        {
            name: '单位转换函数',
            val: 'danweiFun',
            list: []
        },
        {
            name: 'list',
            val: 'list',
            list: []
        },
        {
            name: 'file',
            list: [],
            val: 'file',
        },
        {
            name: 'str',
            list: [],
            val: 'str',
        },
        {
            name: 'json',
            list: [],
            val: 'json',
        },
        {
            name: 'math',
            list: [],
            val: 'math',
        },
        {
            name: 'time',
            list: [],
            val: 'time',
        },
        {
            name: '其它函数',
            list: [],
            val: 'otherFun',
        },

    ]
    let windowArr = []
    windowArr = setWindFunc(windowProcessors)
    keys.map((item, index) => {
        let str = ''
        // streamProcessors函数
        // functions 过滤
        const { streamProcessors, functions } = extensions[item]
        // 前一个节点属性 过滤
        funArr = setFunctions(functions, funArr, item, nodeObj.sourceCell.attributeList)
        // 拼接后一个节点属性
        funArrAll = setFunctions(functions, funArrAll, item, nodeObj.targetCell.attributeList)
        arr.push({
            name: type.indexOf(item) == -1 ? "其他" : item,
            list: [],
            id: generateId()
        })
        streamProcessors.forEach(element => {
            const { parameterOverloads, parameters, namespace, name } = element
            // parameters && parameters.forEach(p => {
            //     p.defaultValue = ''
            // })
            if (parameterOverloads) {
                parameterOverloads.forEach(load => {
                    let loadStr = load.join(',')
                    str += `${namespace}:${name}(${loadStr})`
                    arr[index].list.push({
                        value: `${namespace}:${name}`,
                        label: namespace,
                        valueType: str,//最后提交的数据
                        id: generateId(),
                        parameters: load.map(loa => {
                            return { defaultValue: '', id: generateId(), name: loa }
                        })
                    })
                    str = ''
                })
            } else {
                // delete数据格式 单独处理
                let newparArr = parameters && parameters.map(de => {
                    return de.name
                })
                let newParStr = newparArr.join(',')
                str += `${namespace}:${name}(${newParStr})`
                arr[index].list.push({
                    value: `${namespace}:${name}`,
                    label: namespace,
                    valueType: str,//最后提交的数据
                    id: generateId(),
                    parameters: newparArr.map(loa => {
                        return { defaultValue: '', id: generateId(), name: loa }
                    })
                })
                str = ''
            }



        });
    })
    arr = unique(arr)
    const arrNoOperator = _.cloneDeep(funArr)
    // 添加操作符
    funArrAll = addOperator(funArrAll)
    funArr = addOperator(funArr)
    const obj = {
        arr,//函数类型
        funArr, //过滤 前节点属性
        arrNoOperator, ////过滤 前节点属性 不带操作符
        windowArr,//窗口
        funArrAll, //过滤 后节点属性
    }
    console.log('最终拼接的', arr)
    return obj
}
// 添加操作符
function addOperator(arr) {
    const newArr = _.cloneDeep(arr)
    newArr.push({
        name: "操作符",
        val: "操作符",
        list: [
            {
                id: generateId(),
                name: "==",
                value: "==",
                valueType: "==",
            },
            {
                id: generateId(),
                name: '>=',
                value: '>=',
                valueType: '>=',
            },
            {
                id: generateId(),
                name: '<=',
                value: '<=',
                valueType: '<='
            },
            {
                id: generateId(),
                name: '>',
                value: '>',
                valueType: '>',
            },
            {
                id: generateId(),
                name: '<',
                value: '<',
                valueType: '<',
            },
            {
                id: generateId(),
                name: 'AND',
                value: 'AND',
                valueType: 'AND',
            },
            {
                id: generateId(),
                name: 'OR',
                value: 'OR',
                valueType: 'OR',
            },
            {
                id: generateId(),
                name: 'NOT',
                value: 'NOT',
                valueType: 'NOT',
            },
            {
                id: generateId(),
                name: 'IN',
                value: 'IN',
                valueType: 'IN',
            },
            {
                id: generateId(),
                name: 'IS NULL',
                value: 'IS NULL',
                valueType: 'IS NULL',
            },
        ]
    })
    return newArr
}
// 窗口函数拼接
function setWindFunc(data) {

    let newData = JSON.parse(JSON.stringify(data))
    let arr = [{
        name: '常用',
        val: 'changyong',
        list: []
    },
    {
        name: '其他',
        val: 'qita',
        list: []
    },
        // {
        //     name: '属性',
        //     val: 'shuxing',
        //     list: []
        // }
    ]
    newData.map((item, index) => {
        let parStr = ''
        const { parameterOverloads } = item
        parameterOverloads.forEach(p => {
            // 拼接动态属性的参数
            let parametersArr = []
            p.forEach(i => {
                parametersArr.push({
                    name: i,
                    defaultValue: ''
                })
            })
            parStr = p.join(',')
            const obj = {
                name: item.name,
                value: `${item.name}`,
                parameters: parametersArr,
                valueType: `${item.name}(${parStr})`,//最后提交的数据
            }
            obj.value = `${item.name}(${parStr})`
            if (windType.indexOf(item.name) != -1) {
                arr[0].list.push(obj)
            } else {
                arr[1].list.push(obj)
            }
        })
    })
    return arr
}
// 区分聚合函数和函数
function setFunctions(data, funArr, item, nodeList) {
    // funType 类型
    let newData = data && JSON.parse(JSON.stringify(data)) //function
    let newNodeList = nodeList && JSON.parse(JSON.stringify(nodeList)) //节点(上或者下)
    let newFunArr = funArr && JSON.parse(JSON.stringify(funArr)) //节点(上或者下)

    newData.forEach(f => {
        let loads = f.parameterOverloads && f.parameterOverloads.join(',')
        // incrementalAggregator 聚合函数 不带:
        if (item == 'incrementalAggregator') {
            f.value = `${f.name}`
            f.valueType = `${f.name}(${loads})`
            newFunArr[1].list.push(f)
        } else if (item == 'unitconversion') {
            f.value = `${f.namespace}:${f.name}`
            f.valueType = `${f.namespace}:${f.name}(${loads})`
            // 单位转换函数
            // newFunArr[2].list.push(f)
            newFunArr[2].list.push(f)
        } else {
            f.value = `${f.namespace}:${f.name}`
            f.valueType = `${f.namespace}:${f.name}(${loads})`
            // newFunArr[1].list.push(f)
            let findObj = newFunArr.find(it => it.name === item)
            // 找到了赋值,找不到添加到其他函数内
            if (findObj) {
                findObj.list.push(f)
            } else {
                // findObj[findObj.length - 1]其他函数在newFunArr数组的最后一个
                newFunArr[newFunArr.length - 1].list.push(f)
            }
        }


    })
    // 属性
    newNodeList = newNodeList ? newNodeList.map(item => {
        return {
            value: item.name,
            valueType: item.name,
            id: generateId(),
            name: item.name
        }
    }) : []
    newFunArr[0].list = newNodeList
    return newFunArr
}
//合并相同
function unique(arr) {
    if (!Array.isArray(arr)) {
        console.log('type error!')
        return
    }
    let newData = JSON.parse(JSON.stringify(arr))
    for (var i = 0; i < newData.length; i++) {
        for (var j = i + 1; j < newData.length; j++) {
            if (newData[i].name == newData[j].name) {
                newData[i].list = newData[i].list.concat(newData[j].list)
                newData.splice(j, 1)
                j--;
            }
        }
    }

    return newData
}
export function setDataKey(type) {
    var exKey = ''
    switch (type) {
        case 'FILTER':
            exKey = 'funArr'
            break;
        case 'FUNCTION':
            exKey = 'arr'
            break;
        case 'WINDOW':
            exKey = 'windowArr'
            break;
        default:
            break;
    }
    return exKey
}
// 回显的流处理数据
export function setStreamHandlerList(arr, extensions) {
    let newArr = _.cloneDeep(arr)
    let newExtensions = _.cloneDeep(extensions)
    newArr.forEach((item) => {
        item.name = setTypeName(item.type);
        item.title = setTypeName(item.type);
        item.id = generateId();
        item.showItem = false;
        if (
            item.title !== "筛选" &&
            item.value &&
            item.value.parameters
        ) {
            // 太难了.......
            // 设置一个默认值
            item.value.valueType = item.value.function
            const key = setDataKey(item.type);
            newExtensions[key].forEach((ex) => {
                // 是否是同一个
                ex.list.forEach((e, eIndex) => {
                    if (
                        e.value.indexOf(item.value.function) >= 0 && item.value.parameters.length == e.parameters.length
                    ) {
                        item.value.parameters = item.value.parameters.map(
                            (v, i) => {

                                if (!_.isObject(v)) {
                                    return {
                                        defaultValue: v,
                                        id: generateId(),
                                        name: e.parameters[i]?.name || '',
                                    };
                                } else {
                                    return v
                                }

                            }
                        );

                    }
                    // 判断是否是... (sidd返回的属性比本地存储的属性要长说明是带...的)
                    if (item.value.function === e.value && item.value.parameters.length > e.parameters.length) {
                        // 循环写的太多了,防止出现赋值过了,又进来了
                        if (ifArrObj(item.value.parameters)) {
                            return
                        }
                        item.value.parameters = item.value.parameters.map(
                            (v, i) => {
                                return {
                                    defaultValue: v,
                                    id: generateId(),
                                    name: e.parameters[i]?.name || '',
                                    isAdd: i == item.value.parameters.length - 1 ? true : false
                                };

                            }
                        );
                    }
                });
            });
        } else {
            // item.value = `'${item.value}'`;
        }
    });
    return newArr
}
function ifArrObj(arr) {
    let newArr = _.cloneDeep(arr)
    return newArr.every(item => {
        return Object.prototype.toString.call(item) === '[object Object]'
    })
}
function setTypeName(type) {
    var newType = "";
    switch (type) {
        case "FUNCTION":
            newType = "功能函数";
            break;
        case "FILTER":
            newType = "筛选";
            break;
        case "WINDOW":
            newType = "窗口";
            break;
        default:
            break;
    }
    return newType;
}
// 下一个节点的属性列表整理
export function settargetCellAttr(arr, name) {
    let newArr = _.cloneDeep(arr)
    return newArr.map((item) => {
        return {
            ...item,
            value: name ? name + "." + item.name : item.name,
            label: name ? name + "." + item.name : item.name,
            expression: name ? name + "." + item.name : item.name,
            name: name ? name + "." + item.name : item.name,
            as: name ? name + "." + item.name : item.name,
            id: generateId(),
        };
    });
}
// 上一个节点属性列表亨利
export function setSourceCellAttr(arr, name) {
    let newArr = _.cloneDeep(arr)
    return newArr.map((item) => {
        return { ...item, value: name ? name + '.' + item.name : item.name };
    });
}
// 用户自定义属性和后一个节点合并-关联
export function setUserAttr(userAttr, tagAttr) {

    let newUserAttr = _.cloneDeep(userAttr)
    // console.log(newUserAttr, 'userAttr')
    // console.log(tagAttr, 'tagAttr')

    let newTagAttr = _.cloneDeep(tagAttr)
    newTagAttr = newTagAttr && newTagAttr.map(item => {
        return {
            expression: '', //表达式
            as: item.name, //作为-不可编辑
            id: generateId()
        }
    })
    if (userAttr.length === 0) {
        return newTagAttr
    }

    const newArr = array_diff(newTagAttr || [], newUserAttr || [])
    // console.log(newArr, 'result')
    return newArr
}
function array_diff(a, b) {
    for (var i = 0; i < a.length; i++) {
        // a[j].expression = b[i].expression
        a[i].expression = b[i] && b[i].expression
    }
    return a;
}